// product-detail.js
const collectionUtil = require('../../utils/collectionUtil.js')

Page({
  data: {
    product: {},
    productImages: [],
    productFeatures: [],
    currentImageIndex: 0,
    loading: true,
    isCollected: false,
    showImagePreview: false
  },

  onLoad(options) {
    const productId = options.id
    console.log('商品详情页面加载，商品ID:', productId)
    
    if (productId) {
      this.loadProductDetail(productId)
    } else {
      wx.showToast({
        title: '商品ID无效',
        icon: 'none'
      })
      setTimeout(() => {
        wx.navigateBack()
      }, 1500)
    }
  },

  // 加载商品详情
  loadProductDetail(productId) {
    this.setData({ loading: true })
    
    wx.request({
      url: `http://localhost:8081/product/productById?id=${productId}`,
      method: 'GET',
      success: (res) => {
        console.log('商品详情API响应:', res.data)
        
        if (res.statusCode === 200 && res.data) {
          this.processProductData(res.data)
        } else {
          console.error('商品详情API返回错误:', res)
          wx.showToast({
            title: '获取商品详情失败',
            icon: 'none'
          })
          setTimeout(() => {
            wx.navigateBack()
          }, 1500)
        }
      },
      fail: (err) => {
        console.error('获取商品详情失败:', err)
        wx.showToast({
          title: '网络错误',
          icon: 'none'
        })
        setTimeout(() => {
          wx.navigateBack()
        }, 1500)
      },
      complete: () => {
        this.setData({ loading: false })
      }
    })
  },

  // 处理商品数据
  processProductData(productData) {
    console.log('处理商品数据:', productData)
    
    // 处理商品图片
    const productImages = []
    if (productData.cover) {
      productImages.push(productData.cover)
    }
    if (productData.images) {
      const images = productData.images.split(',').filter(img => img.trim())
      productImages.push(...images)
    }
    
    // 处理商品特性（根据商品类型生成）
    const productFeatures = this.generateProductFeatures(productData)
    
    // 处理商品信息
    const product = {
      id: productData.id,
      name: productData.name,
      cover: productData.cover || 'https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=400&h=400&fit=crop&crop=center',
      price: productData.price || 0,
      originalPrice: productData.originalPrice || 0,
      sales: productData.sales || 0,
      stock: productData.stock || 0,
      intro: productData.intro || '',
      detail: productData.detail || '',
      status: productData.status || 1,
      category: productData.category || {},
      createTime: productData.createTime,
      updateTime: productData.updateTime
    }

    this.setData({
      product,
      productImages: productImages.length > 0 ? productImages : [product.cover],
      productFeatures
    })

    // 检查收藏状态
    this.checkCollectionStatus(product.id)

    console.log('商品数据处理完成:', {
      name: product.name,
      price: product.price,
      images: productImages.length,
      features: productFeatures.length
    })
  },

  // 检查收藏状态
  async checkCollectionStatus(productId) {
    const userId = 2 // 实际应该从用户信息获取
    
    try {
      const isCollected = await collectionUtil.checkCollectionStatus(userId, 'product', productId)
      this.setData({
        isCollected: isCollected
      })
    } catch (error) {
      console.error('检查收藏状态失败:', error)
      // 失败时默认为未收藏
      this.setData({
        isCollected: false
      })
    }
  },

  // 生成商品特性
  generateProductFeatures(productData) {
    const features = []
    
    // 根据商品名称和分类生成特性
    if (productData.name && productData.name.includes('按摩')) {
      features.push('正反揉捏', '温热按摩', '升级20头')
    } else if (productData.name && productData.name.includes('艾灸')) {
      features.push('温灸理疗', '无烟设计', '定时功能')
    } else if (productData.name && productData.name.includes('书籍')) {
      features.push('权威专家', '图文并茂', '实用性强')
    } else {
      features.push('品质保证', '正品正货', '售后服务')
    }
    
    return features
  },

  // 图片预览
  onImageTap(e) {
    const index = e.currentTarget.dataset.index
    this.setData({
      currentImageIndex: index,
      showImagePreview: true
    })
  },

  // 关闭图片预览
  onCloseImagePreview() {
    this.setData({
      showImagePreview: false
    })
  },

  // 收藏/取消收藏
  onCollect() {
    const isCollected = !this.data.isCollected
    const productId = this.data.product.id
    
    if (isCollected) {
      // 添加收藏
      this.addCollection(productId)
    } else {
      // 取消收藏
      this.removeCollection(productId)
    }
  },

  // 添加收藏
  async addCollection(productId) {
    const userId = 2 // 实际应该从用户信息获取
    
    try {
      const result = await collectionUtil.addCollection(userId, 'product', productId)
      if (result.success) {
        this.setData({
          isCollected: true
        })
        collectionUtil.showResult(result, '收藏成功')
      } else {
        collectionUtil.showResult(result, '收藏成功', '收藏失败')
      }
    } catch (error) {
      console.error('收藏失败:', error)
      collectionUtil.showResult(error, '收藏成功', '收藏失败')
    }
  },

  // 取消收藏
  async removeCollection(productId) {
    const userId = 2 // 实际应该从用户信息获取
    
    try {
      const result = await collectionUtil.removeCollection(userId, 'product', productId)
      if (result.success) {
        this.setData({
          isCollected: false
        })
        collectionUtil.showResult(result, '取消收藏')
      } else {
        collectionUtil.showResult(result, '取消收藏', '取消收藏失败')
      }
    } catch (error) {
      console.error('取消收藏失败:', error)
      collectionUtil.showResult(error, '取消收藏', '取消收藏失败')
    }
  },

  // 立即购买
  onBuyNow() {
    if (this.data.product.stock <= 0) {
      wx.showToast({
        title: '商品已售罄',
        icon: 'none'
      })
      return
    }

    // 检查用户是否已登录
    const app = getApp()
    const userInfo = app.getUserInfo()
    if (!userInfo || !userInfo.isLogin) {
      wx.showModal({
        title: '请先登录',
        content: '购买商品需要先登录，是否立即登录？',
        confirmText: '立即登录',
        cancelText: '取消',
        success: (res) => {
          if (res.confirm) {
            wx.navigateTo({
              url: '/pages/login/login'
            })
          }
        }
      })
      return
    }

    // 直接创建订单，不选择支付方式
    this.createOrder()
  },

  // 创建订单
  createOrder() {
    const app = getApp()
    const userInfo = app.getUserInfo()
    
    // 验证必要数据
    if (!this.validateOrderData(userInfo)) {
      return
    }
    
    // 生成订单编号
    const orderNo = this.generateOrderNo()
    
    // 构建订单数据 - 根据order表结构调整字段名
    const orderData = {
      orderNo: orderNo,  // 使用驼峰命名
      productid: this.data.product.id,
      userId: userInfo.userId || userInfo.id,  // 使用驼峰命名
      totalAmount: parseFloat(this.data.product.price),  // 发送数字类型
      payAmount: parseFloat(this.data.product.price),  // 发送数字类型
      discountAmount: 0.00,  // 使用驼峰命名
      payType: 'alipay',  // 默认使用支付宝支付
      status: 'pending'
    }

    console.log('创建订单数据:', orderData)
    console.log('API请求URL:', 'http://localhost:8081/product/OrderAdd')
    console.log('请求头:', { 'Content-Type': 'application/json' })

    // 保存订单数据，供后续使用
    this.setData({
      orderData: orderData
    })

    // 显示加载提示
    wx.showLoading({
      title: '正在创建订单...'
    })

    // 调用创建订单API
    wx.request({
      url: 'http://localhost:8081/product/OrderAdd',
      method: 'POST',
      header: {
        'Content-Type': 'application/json'
      },
      data: orderData,
      timeout: 10000, // 10秒超时
      success: (res) => {
        wx.hideLoading()
        console.log('创建订单API响应状态码:', res.statusCode)
        console.log('创建订单API响应数据:', res.data)
        console.log('创建订单API响应头:', res.header)
        console.log('响应数据类型:', typeof res.data)
        console.log('响应数据是否为数组:', Array.isArray(res.data))
        if (res.data && typeof res.data === 'object') {
          console.log('响应数据的所有键:', Object.keys(res.data))
          console.log('res.data.id:', res.data.id)
          console.log('res.data.orderId:', res.data.orderId)
          console.log('res.data.id类型:', typeof res.data.id)
          console.log('res.data.orderId类型:', typeof res.data.orderId)
        }
        
        if (res.statusCode === 200 && res.data) {
          // 获取订单ID - 确保是数字类型
          let orderId = null
          
          // 尝试从不同字段获取订单ID
          if (res.data.id && typeof res.data.id === 'number') {
            orderId = res.data.id
          } else if (res.data.orderId && typeof res.data.orderId === 'number') {
            orderId = res.data.orderId
          } else if (typeof res.data === 'number') {
            orderId = res.data
          } else if (res.data.id && !isNaN(parseInt(res.data.id))) {
            orderId = parseInt(res.data.id)
          } else if (res.data.orderId && !isNaN(parseInt(res.data.orderId))) {
            orderId = parseInt(res.data.orderId)
          }
          
          console.log('订单创建成功，原始响应:', res.data)
          console.log('提取的订单ID:', orderId)
          console.log('订单ID类型:', typeof orderId)
          
          // 如果没有获取到订单ID，尝试从订单列表获取最新订单
          if (!orderId) {
            console.warn('API未返回订单ID，尝试从订单列表获取最新订单')
            this.getLatestOrderId(orderData.orderNo)
            return
          }
          
          // 订单创建成功，显示成功提示
          wx.showModal({
            title: '订单创建成功',
            content: `订单号：${orderData.orderNo}\n金额：¥${orderData.payAmount}\n支付方式：支付宝支付`,
            showCancel: false,
            confirmText: '查看订单',
            success: (modalRes) => {
              if (modalRes.confirm) {
                console.log('准备跳转到订单详情页面，订单ID:', orderId)
                // 跳转到订单详情页面
                wx.navigateTo({
                  url: `/pages/order-detail/order-detail?id=${orderId}`,
                  fail: (err) => {
                    console.error('跳转到订单详情页面失败:', err)
                    // 如果订单详情页面不存在，跳转到订单列表
                    wx.switchTab({
                      url: '/pages/user/user'
                    })
                  }
                })
              }
            }
          })
        } else {
          console.error('创建订单失败:', res.data)
          
          // 如果是500错误，尝试使用下划线命名格式
          if (res.statusCode === 500) {
            console.log('尝试使用下划线命名格式重新创建订单')
            this.createOrderWithUnderscoreFormat(orderNo, userInfo)
            return
          }
          
          wx.showModal({
            title: '创建订单失败',
            content: res.data.message || res.data.error || '请稍后重试',
            showCancel: false,
            confirmText: '确定'
          })
        }
      },
      fail: (err) => {
        wx.hideLoading()
        console.error('创建订单失败:', err)
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        })
      }
    })
  },

  // 验证订单数据
  validateOrderData(userInfo) {
    // 验证用户信息
    if (!userInfo || !userInfo.isLogin) {
      wx.showToast({
        title: '用户未登录',
        icon: 'none'
      })
      return false
    }

    if (!userInfo.userId && !userInfo.id) {
      wx.showToast({
        title: '用户ID不存在',
        icon: 'none'
      })
      return false
    }

    // 验证商品信息
    if (!this.data.product || !this.data.product.id) {
      wx.showToast({
        title: '商品信息不完整',
        icon: 'none'
      })
      return false
    }

    if (!this.data.product.price || this.data.product.price <= 0) {
      wx.showToast({
        title: '商品价格无效',
        icon: 'none'
      })
      return false
    }

    if (this.data.product.stock <= 0) {
      wx.showToast({
        title: '商品库存不足',
        icon: 'none'
      })
      return false
    }

    return true
  },

  // 使用下划线命名格式创建订单（备用方法）
  createOrderWithUnderscoreFormat(orderNo, userInfo) {
    const orderData = {
      order_no: orderNo,  // 使用下划线命名
      productid: this.data.product.id,
      user_id: userInfo.userId || userInfo.id,  // 使用下划线命名
      total_amount: parseFloat(this.data.product.price),  // 发送数字类型
      pay_amount: parseFloat(this.data.product.price),  // 发送数字类型
      discount_amount: 0.00,  // 使用下划线命名
      pay_type: 'alipay',  // 默认使用支付宝支付
      status: 'pending'
    }

    console.log('使用下划线格式创建订单数据:', orderData)

    wx.request({
      url: 'http://localhost:8081/product/OrderAdd',
      method: 'POST',
      header: {
        'Content-Type': 'application/json'
      },
      data: orderData,
      timeout: 10000,
      success: (res) => {
        wx.hideLoading()
        console.log('下划线格式API响应:', res.data)
        
        if (res.statusCode === 200 && res.data) {
          // 获取订单ID
          let orderId = null
          if (res.data.id && typeof res.data.id === 'number') {
            orderId = res.data.id
          } else if (res.data.id && !isNaN(parseInt(res.data.id))) {
            orderId = parseInt(res.data.id)
          } else {
            console.warn('下划线格式API未返回订单ID，跳转到订单列表')
            wx.showModal({
              title: '订单创建成功',
              content: `订单号：${orderData.order_no}\n金额：¥${orderData.pay_amount}\n支付方式：支付宝支付\n\n订单详情稍后可在订单列表中查看`,
              showCancel: false,
              confirmText: '查看订单列表',
              success: () => {
                wx.switchTab({
                  url: '/pages/user/user'
                })
              }
            })
            return
          }
          
          console.log('下划线格式订单创建成功，订单ID:', orderId)
          
          wx.showModal({
            title: '订单创建成功',
            content: `订单号：${orderData.order_no}\n金额：¥${orderData.pay_amount}\n支付方式：支付宝支付`,
            showCancel: false,
            confirmText: '查看订单',
            success: (modalRes) => {
              if (modalRes.confirm) {
                wx.navigateTo({
                  url: `/pages/order-detail/order-detail?id=${orderId}`,
                  fail: () => {
                    wx.switchTab({
                      url: '/pages/user/user'
                    })
                  }
                })
              }
            }
          })
        } else {
          wx.showModal({
            title: '创建订单失败',
            content: '服务器错误，请稍后重试',
            showCancel: false,
            confirmText: '确定'
          })
        }
      },
      fail: (err) => {
        wx.hideLoading()
        console.error('下划线格式创建订单失败:', err)
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        })
      }
    })
  },

  // 获取最新订单ID
  getLatestOrderId(orderNo) {
    const app = getApp()
    const userInfo = app.getUserInfo()
    const userId = userInfo.userId || userInfo.id
    
    if (!userId) {
      console.error('用户ID不存在，无法获取订单列表')
      this.showOrderSuccessAndRedirect(orderNo)
      return
    }
    
    wx.request({
      url: `http://localhost:8081/product/OrderByUserId?userId=${userId}`,
      method: 'GET',
      success: (res) => {
        console.log('获取订单列表响应:', res.data)
        
        if (res.statusCode === 200 && Array.isArray(res.data) && res.data.length > 0) {
          // 查找匹配的订单
          const matchingOrder = res.data.find(order => order.orderNo === orderNo)
          if (matchingOrder) {
            console.log('找到匹配的订单，ID:', matchingOrder.id)
            this.showOrderSuccessAndRedirect(orderNo, matchingOrder.id)
          } else {
            console.log('未找到匹配的订单，使用最新订单')
            const latestOrder = res.data[0] // 假设第一个是最新的
            this.showOrderSuccessAndRedirect(orderNo, latestOrder.id)
          }
        } else {
          console.log('订单列表为空或获取失败')
          this.showOrderSuccessAndRedirect(orderNo)
        }
      },
      fail: (err) => {
        console.error('获取订单列表失败:', err)
        this.showOrderSuccessAndRedirect(orderNo)
      }
    })
  },

  // 显示订单成功信息并跳转
  showOrderSuccessAndRedirect(orderNo, orderId = null) {
    const orderData = this.data.orderData || {}
    
    wx.showModal({
      title: '订单创建成功',
      content: `订单号：${orderNo}\n金额：¥${orderData.payAmount || orderData.pay_amount || '0'}\n支付方式：支付宝支付`,
      showCancel: false,
      confirmText: orderId ? '查看订单' : '查看订单列表',
      success: (res) => {
        if (res.confirm) {
          if (orderId) {
            // 跳转到订单详情页面
            wx.navigateTo({
              url: `/pages/order-detail/order-detail?id=${orderId}`,
              fail: () => {
                wx.switchTab({
                  url: '/pages/user/user'
                })
              }
            })
          } else {
            // 跳转到订单列表页面
            wx.switchTab({
              url: '/pages/user/user'
            })
          }
        }
      }
    })
  },

  // 生成订单编号
  generateOrderNo() {
    const now = new Date()
    const year = now.getFullYear()
    const month = String(now.getMonth() + 1).padStart(2, '0')
    const day = String(now.getDate()).padStart(2, '0')
    const hours = String(now.getHours()).padStart(2, '0')
    const minutes = String(now.getMinutes()).padStart(2, '0')
    const seconds = String(now.getSeconds()).padStart(2, '0')
    const random = Math.floor(Math.random() * 1000).toString().padStart(3, '0')
    
    return `ORD${year}${month}${day}${hours}${minutes}${seconds}${random}`
  },

  // 联系客服
  onContactService() {
    wx.navigateTo({
      url: '/pages/customer-service/customer-service'
    })
  },

  // 分享商品
  onShare() {
    return {
      title: this.data.product.name,
      path: `/pages/product-detail/product-detail?id=${this.data.product.id}`,
      imageUrl: this.data.product.cover
    }
  }
})